const jwt = require('jsonwebtoken');
const db = require('../models');

/**
 * JWT认证中间件
 */
const authenticateToken = async (req, res, next) => {
  try {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

    if (!token) {
      return res.status(401).json({
        error: '访问令牌不存在',
        code: 'TOKEN_MISSING'
      });
    }

    // 验证token
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    
    // 查找用户
    const user = await db.User.findByPk(decoded.userId, {
      attributes: { exclude: ['password'] }
    });

    if (!user) {
      return res.status(401).json({
        error: '用户不存在',
        code: 'USER_NOT_FOUND'
      });
    }

    if (user.status !== 'active') {
      return res.status(401).json({
        error: '用户账户已被禁用',
        code: 'USER_DISABLED'
      });
    }

    req.user = user;
    next();
  } catch (error) {
    if (error.name === 'JsonWebTokenError') {
      return res.status(401).json({
        error: '无效的访问令牌',
        code: 'TOKEN_INVALID'
      });
    }
    
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({
        error: '访问令牌已过期',
        code: 'TOKEN_EXPIRED'
      });
    }

    console.error('认证中间件错误:', error);
    return res.status(500).json({
      error: '服务器内部错误',
      code: 'INTERNAL_ERROR'
    });
  }
};

/**
 * 可选认证中间件 - 不强制要求登录
 */
const optionalAuth = async (req, res, next) => {
  try {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];

    if (token) {
      const decoded = jwt.verify(token, process.env.JWT_SECRET);
      const user = await db.User.findByPk(decoded.userId, {
        attributes: { exclude: ['password'] }
      });
      
      if (user && user.status === 'active') {
        req.user = user;
      }
    }

    next();
  } catch (error) {
    // 可选认证失败时不返回错误，继续执行
    next();
  }
};

/**
 * 管理员认证中间件
 */
const authenticateAdmin = async (req, res, next) => {
  try {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];

    if (!token) {
      return res.status(401).json({
        error: '管理员令牌不存在',
        code: 'ADMIN_TOKEN_MISSING'
      });
    }

    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    
    const admin = await db.Admin.findByPk(decoded.adminId, {
      attributes: { exclude: ['password'] }
    });

    if (!admin) {
      return res.status(401).json({
        error: '管理员不存在',
        code: 'ADMIN_NOT_FOUND'
      });
    }

    if (admin.status !== 'active') {
      return res.status(401).json({
        error: '管理员账户已被禁用',
        code: 'ADMIN_DISABLED'
      });
    }

    req.admin = admin;
    next();
  } catch (error) {
    if (error.name === 'JsonWebTokenError') {
      return res.status(401).json({
        error: '无效的管理员令牌',
        code: 'ADMIN_TOKEN_INVALID'
      });
    }
    
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({
        error: '管理员令牌已过期',
        code: 'ADMIN_TOKEN_EXPIRED'
      });
    }

    console.error('管理员认证中间件错误:', error);
    return res.status(500).json({
      error: '服务器内部错误',
      code: 'INTERNAL_ERROR'
    });
  }
};

/**
 * 权限检查中间件
 */
const checkPermission = (permission) => {
  return (req, res, next) => {
    if (!req.admin) {
      return res.status(401).json({
        error: '需要管理员权限',
        code: 'ADMIN_REQUIRED'
      });
    }

    if (!req.admin.permissions || !req.admin.permissions.includes(permission)) {
      return res.status(403).json({
        error: '权限不足',
        code: 'PERMISSION_DENIED',
        required: permission
      });
    }

    next();
  };
};

module.exports = {
  authenticateToken,
  optionalAuth,
  authenticateAdmin,
  checkPermission
}; 